"""
'''
这其实是道NOIP的原题，只不过他换成了n行m列的，原题是n行n列。
这里有个讲得挺好的：http://www.360doc.com/content/19/0303/18/32937624_818850981.shtml
'''
n, m = map(int, input().split())
a = [[0 for j in range(m + 1)] for i in range(n + 1)]
nn = [i + 1 for i in range(n)]# n = 3: [1, 2, 3]
mm = [i + 1 for i in range(m)]
for i in nn:
    a[i] = [0, *map(int, input().split())]
# a数组大概长这样：
# for i in a: print(i)
'''
[0, 0, 0, 0]
[0, 0, 2, 9]
[0, 4, 8, 6]
[0, 2, 7, 0]
就是左边和上边多了一层0
实现的是java中
int[][] a = new int[n + 1][m + 1];
for (int i = 1; i <= n; ++ i) {
    for (int j = 1; j <= m; ++ j) {
        a[i][j] = sc.nextInt();
    }
}
的效果。
'''
dp = [[[[0 for l in range(m + 1)] for k in range(n + 1)] for j in range(m + 1)] for i in range(n + 1)]
for i in nn:
    for j in mm:
        for k in nn:
            for l in mm:
                if i != k or j != l:
                    dp[i][j][k][l] = max(
                        dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1],
                        dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]
                    ) + a[i][j] + a[k][l]
                else: # 因为i==k and j==l时，a[i][j] = a[k][l]，相当于他们走到同一个点了，只有一个算数。
                    dp[i][j][k][l] = max(
                        dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1],
                        dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]
                    ) + a[i][j]
print(dp[n][m][n][m])
# 果然超时了，这个是O(n^4)的方法。听说有O(n^3)的方法，再写写试试。啊这，研究了一些题解，他说的优化到0(n^3)应该说的是空间复杂度。。
"""
# emmmmmmm，看了洛谷上大神的解法。稍加改动，改出了这个题的答案。
# https://www.luogu.com.cn/problem/solution/P1004
# 看那个以墨那个人写的题解。2017年写的。只不过原题是n行n列，所以他是n*2，咱们这个题是n行m列，所以是n+m。
# 顺便他应该是越界了。。。但是不知道为啥他那里没错。。咱们这儿注意一下。
# 实在看不懂的话，建议学了01背包的一维数组版本再看这个。
n, m = map(int, input().split())
a = [[0 for j in range(n + m + 1)] for i in range(n + m + 1)]
for i in range(1, n + 1):
    a[i][1: m + 1] = [*map(int, input().split())]
dp = [[0 for j in range(n + m + 1)] for i in range(n + m + 1)]
for l in range(2, n + m + 1):
    for i in range(l - 1, 0, -1):
        for ii in range(l - 1, 0, -1):
            j, jj = l - i, l - ii
            # 加这个也可以。顺便这个应该可以取短边来做？不过应该差不多吧？反正最后肯定要有50，50这种的。不过好像真的可以把a的空间复杂度优化到O(nm)，dp的空间复杂度优化到O(min(n, m)^2)。
            if i > n or ii > n or j > m or jj > m: continue
            dp[i][ii] = max(
                dp[i - 1][ii], dp[i][ii - 1],
                dp[i][ii], dp[i - 1][ii - 1]
            ) + a[i][j]
            dp[i][ii] += a[ii][jj] * int(i != ii)
# 然后这里是唯一需要注意的点，我之前写的dp[n][m]，错了。这是为什么呢？
# 实际上差不多看懂他的题解之后，你就能发现，dp的两维存的都是行坐标。所以就是dp[n][n]就行了。
print(dp[n][n])
# 真的强！这个的时间复杂度应该是小于O((n+m)^3)的，空间复杂度也只有O((n+m)^2)。
# -------------------------------------------------------------------------------

# 比赛环境为python3.8.6版本自带的IDLE，最好早点熟悉一下。。这个东西的提示时有时无

# 菜单栏最右边的Help的Python Docs 比赛时候也可以看，不过建议还是提前多了解了解，

# 比赛的时候至少知道在文档找什么能用的上。

# IDLE是下载Python时自带的，在按住win+s搜索IDLE就能搜到了。

# 然后点左上角的File可以创建新文件，然后按F5可以运行。
